<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <meta name="keywords" content="Hexo Theme Keep">
    <meta name="description" content="Hexo Theme Keep">
    <meta name="author" content="Blank">
    
    <title>
        
            Java基础-图谱&amp;Q/A |
        
        Blankの博客
    </title>
    
<link rel="stylesheet" href="/css/style.css">

    <link rel="shortcut icon" href="/images/logo.jpg">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/font/css/fontawesome.min.css">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/font/css/regular.min.css">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/font/css/solid.min.css">
    <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/font/css/brands.min.css">
    <script id="hexo-configurations">
    let KEEP = window.KEEP || {}
    KEEP.hexo_config = {"hostname":"example.com","root":"/","language":"zh-CN","path":"search.json"}
    KEEP.theme_config = {"toc":{"enable":true,"number":true,"expand_all":true,"init_open":true},"style":{"primary_color":"#0066cc","logo":"/images/logo.jpg","favicon":"/images/logo.jpg","avatar":"/images/logo.jpg","font_size":"18px","font_family":"STKaiti","hover":{"shadow":true,"scale":true},"first_screen":{"enable":true,"header_transparent":true,"background_img":"/images/bg.svg","description":"Keep writing and Keep loving.","font_color":null,"hitokoto":true},"scroll":{"progress_bar":true,"percent":true}},"local_search":{"enable":true,"preload":true},"code_copy":{},"code_block":{"tools":{"enable":true,"style":"mac"},"highlight_theme":"default"},"side_tools":{},"pjax":{"enable":true},"lazyload":{"enable":true},"comment":{"enable":false,"use":"gitalk","valine":{"appid":null,"appkey":null,"server_urls":null,"placeholder":null},"gitalk":{"github_id":"5ober","github_admins":"5ober","repository":"hexo-blog-comments","client_id":"40d85a7b36388c0b5094","client_secret":"6c7eab92d24b6f1bdfbcdf077c73e86841b35d5e","proxy":null},"twikoo":{"env_id":null,"region":null,"version":"1.6.8"},"waline":{"server_url":null,"reaction":false,"version":2}},"post":{"author_label":{"enable":true,"auto":false,"custom_label_list":["Trainee","Engineer","Java工程师"]},"word_count":{"enable":true,"wordcount":true,"min2read":true},"img_align":"left","copyright_info":true},"version":"3.6.1"}
    KEEP.language_ago = {"second":"%s 秒前","minute":"%s 分钟前","hour":"%s 小时前","day":"%s 天前","week":"%s 周前","month":"%s 个月前","year":"%s 年前"}
    KEEP.language_code_block = {"copy":"复制代码","copied":"已复制","fold":"折叠代码块","folded":"已折叠"}
    KEEP.language_copy_copyright = {"copy":"复制版权信息","copied":"已复制","title":"原文标题","author":"原文作者","link":"原文链接"}
  </script>
<meta name="generator" content="Hexo 6.3.0"><link rel="alternate" href="/atom.xml" title="Blankの博客" type="application/atom+xml">
</head>


<body>
<div class="progress-bar-container">
    
        <span class="scroll-progress-bar"></span>
    

    
        <span class="pjax-progress-bar"></span>
        <i class="pjax-progress-icon fas fa-circle-notch fa-spin"></i>
    
</div>


<main class="page-container">

    

    <div class="page-main-content">

        <div class="page-main-content-top">
            
<header class="header-wrapper">

    <div class="header-content">
        <div class="left">
            
                <a class="logo-image" href="/">
                    <img src="/images/logo.jpg">
                </a>
            
            <a class="logo-title" href="/">
               Blankの博客
            </a>
        </div>

        <div class="right">
            <div class="pc">
                <ul class="menu-list">
                    
                        <li class="menu-item">
                            <a class=""
                               href="/"
                            >
                                首页
                            </a>
                        </li>
                    
                        <li class="menu-item">
                            <a class=""
                               href="/archives"
                            >
                                归档
                            </a>
                        </li>
                    
                        <li class="menu-item">
                            <a class=""
                               href="/tags"
                            >
                                标签
                            </a>
                        </li>
                    
                        <li class="menu-item">
                            <a class=""
                               href="/categories"
                            >
                                分类
                            </a>
                        </li>
                    
                        <li class="menu-item">
                            <a class=""
                               href="/links"
                            >
                                友链
                            </a>
                        </li>
                    
                        <li class="menu-item">
                            <a class=""
                               href="/about"
                            >
                                关于
                            </a>
                        </li>
                    
                    
                        <li class="menu-item search search-popup-trigger">
                            <i class="fas fa-search"></i>
                        </li>
                    
                </ul>
            </div>
            <div class="mobile">
                
                    <div class="icon-item search search-popup-trigger"><i class="fas fa-search"></i></div>
                
                <div class="icon-item menu-bar">
                    <div class="menu-bar-middle"></div>
                </div>
            </div>
        </div>
    </div>

    <div class="header-drawer">
        <ul class="drawer-menu-list">
            
                <li class="drawer-menu-item flex-center">
                    <a class=""
                       href="/">首页</a>
                </li>
            
                <li class="drawer-menu-item flex-center">
                    <a class=""
                       href="/archives">归档</a>
                </li>
            
                <li class="drawer-menu-item flex-center">
                    <a class=""
                       href="/tags">标签</a>
                </li>
            
                <li class="drawer-menu-item flex-center">
                    <a class=""
                       href="/categories">分类</a>
                </li>
            
                <li class="drawer-menu-item flex-center">
                    <a class=""
                       href="/links">友链</a>
                </li>
            
                <li class="drawer-menu-item flex-center">
                    <a class=""
                       href="/about">关于</a>
                </li>
            
        </ul>
    </div>

    <div class="window-mask"></div>

</header>


        </div>

        <div class="page-main-content-middle">

            <div class="main-content">

                
                    <div class="fade-in-down-animation">
    <div class="post-page-container">
        <div class="article-content-container">

            <div class="article-title">
                <span class="title-hover-animation">Java基础-图谱&amp;Q/A</span>
            </div>

            
                <div class="article-header">
                    <div class="avatar">
                        <img src="/images/logo.jpg">
                    </div>
                    <div class="info">
                        <div class="author">
                            <span class="name">Blank</span>
                            
                                <span class="author-label">Java工程师</span>
                            
                        </div>
                        <div class="meta-info">
                            
<div class="article-meta-info">
    <span class="article-date article-meta-item">
        
            <i class="fa-regular fa-calendar-plus"></i>&nbsp;
        
        <span class="pc">2023-02-21 00:51:18</span>
        <span class="mobile">2023-02-21 00:51</span>
    </span>
    
        <span class="article-update-date article-meta-item">
        <i class="fas fa-file-pen"></i>&nbsp;
        <span class="pc">2023-02-20 15:06:58</span>
    </span>
    
    
        <span class="article-categories article-meta-item">
            <i class="fas fa-folder"></i>&nbsp;
            <ul>
                
                    <li>
                        <a href="/categories/java%E5%9F%BA%E7%A1%80/">java基础</a>&nbsp;
                    </li>
                
            </ul>
        </span>
    
    
        <span class="article-tags article-meta-item">
            <i class="fas fa-tags"></i>&nbsp;
            <ul>
                
                    <li>
                        <a href="/tags/Java/">Java</a>&nbsp;
                    </li>
                
            </ul>
        </span>
    

    
    
        <span class="article-wordcount article-meta-item">
            <i class="fas fa-file-word"></i>&nbsp;<span>7.3k 字</span>
        </span>
    
    
        <span class="article-min2read article-meta-item">
            <i class="fas fa-clock"></i>&nbsp;<span>26 分钟</span>
        </span>
    
    
        <span class="article-pv article-meta-item">
            <i class="fas fa-eye"></i>&nbsp;<span id="busuanzi_value_page_pv"></span>
        </span>
    
</div>

                        </div>
                    </div>
                </div>
            

            <div class="article-content keep-markdown-body">
                

                <h1 id="java-基础-图谱-amp-Q-x2F-A"><a href="#java-基础-图谱-amp-Q-x2F-A" class="headerlink" title="java 基础-图谱&amp;Q&#x2F;A"></a>java 基础-图谱&amp;Q&#x2F;A</h1><blockquote>
<p>本文主要对Java基础知识体系小结，同时结合一些Q&amp;A进行理解。</p>
</blockquote>
<ul>
<li>[参考文档]</li>
<li>[知识体系]</li>
<li>Q&amp;A<ul>
<li>[(#java-中应该使用什么数据类型来代表价格) Java 中应该使用什么数据类型来代表价格?]</li>
<li>[怎么将 byte 转换为 String?]</li>
<li>[Java 中怎样将 bytes 转换为 long 类型?]</li>
<li>[我们能将 int 强制转换为 byte 类型的变量吗? 如果该值大于 byte 类型的范围，将会出现什么现象?]</li>
<li>[存在两个类，B 继承 A，C 继承 B，我们能将 B 转换为 C 么? 如 C &#x3D; (C) B；]</li>
<li>[哪个类包含 clone 方法? 是 Cloneable 还是 Object?]</li>
<li>[Java 中 ++ 操作符是线程安全的吗?]</li>
<li>[a &#x3D; a + b 与 a +&#x3D; b 的区别]</li>
<li>[我能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗?]</li>
<li>[3*0.1 &#x3D;&#x3D; 0.3 将会返回什么? true 还是 false?]</li>
<li>[int 和 Integer 哪个会占用更多的内存?]</li>
<li>[为什么 Java 中的 String 是不可变的(Immutable)?]</li>
<li>[我们能在 Switch 中使用 String 吗?]</li>
<li>[Java 中的构造器链是什么?]</li>
<li>[枚举类]</li>
<li>[[什么是不可变对象(immutable object)? Java 中怎么创建一个不可变对象?]</li>
<li>[我们能创建一个包含可变对象的不可变对象吗?]</li>
<li>[有没有可能两个不相等的对象有有相同的 hashcode?]</li>
<li>[两个相同的对象会有不同的的 hash code 吗?]</li>
<li>[我们可以在 hashcode() 中使用随机数字吗?]</li>
<li>[Java 中，Comparator 与 Comparable 有什么不同?]</li>
<li>[为什么在重写 equals 方法的时候需要重写 hashCode 方法?]</li>
<li>[“a&#x3D;&#x3D;b”和”a.equals(b)”有什么区别?]</li>
<li>[a.hashCode() 有什么用? 与 a.equals(b) 有什么关系?]</li>
<li>[final、finalize 和 finally 的不同之处?]</li>
<li>[Java 中的编译期常量是什么? 使用它又什么风险?]</li>
<li>[静态内部类与顶级类有什么区别?]</li>
<li>[Java 中，Serializable 与 Externalizable 的区别?]</li>
<li>[说出 JDK 1.7 中的三个新特性?]</li>
<li>[说出 5 个 JDK 1.8 引入的新特性?]</li>
<li>[接口是什么? 为什么要使用接口而不是直接使用具体类?]</li>
<li>[Java 中，抽象类与接口之间有什么不同?]</li>
<li>[Object有哪些公用方法?]</li>
<li>[equals与&#x3D;&#x3D;的区别]</li>
<li>[String、StringBuffer与StringBuilder的区别]</li>
<li>[switch能否用String做参数]</li>
<li>[接口与抽象类]</li>
<li>[抽象类和最终类]</li>
<li>[异常]</li>
<li>[关于finally]</li>
<li>[受检查异常和运行时异常]</li>
<li>[super出现在父类的子类中。有三种存在方式]</li>
<li>[this() &amp; super()在构造方法中的区别]</li>
<li>[修饰符一览]</li>
<li>[构造内部类和静态内部类对象]</li>
<li>[序列化]</li>
<li>[正则表达式]</li>
<li>[Java移位运算符]</li>
<li>[形参&amp;实参]</li>
<li>[局部变量为什么要初始化]</li>
<li>[Java语言的鲁棒性]</li>
<li>[Java语言特性]</li>
<li>[包装类的equals()方法不处理数据转型，必须类型和值都一样才相等。]</li>
<li>[子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。]</li>
<li>[Java语法糖]</li>
</ul>
</li>
</ul>
<h2 id="参考文档"><a href="#参考文档" class="headerlink" title="参考文档"></a>参考文档</h2><ul>
<li>Thinking in Java (Java 编程思想) Gitbook中文文档 <a class="link"   target="_blank" rel="noopener" href="https://java.quanke.name/" >https://java.quanke.name/<i class="fas fa-external-link-alt"></i></a></li>
<li>Thinking in Java (Java 编程思想) Github <a class="link"   target="_blank" rel="noopener" href="https://github.com/quanke/think-in-java" >https://github.com/quanke/think-in-java<i class="fas fa-external-link-alt"></i></a></li>
<li>Thinking in Java (Java 编程思想) Gitbook2 <a class="link"   target="_blank" rel="noopener" href="https://www.gitbook.com/book/wizardforcel/thinking-in-java/details" >https://www.gitbook.com/book/wizardforcel/thinking-in-java/details<i class="fas fa-external-link-alt"></i></a></li>
</ul>
<h2 id="知识体系"><a href="#知识体系" class="headerlink" title="知识体系"></a>知识体系</h2><p><img  
                     lazyload
                     alt="image"
                     data-src="https://pchaoo.gitee.io/blog/img/java_basic.png"
                      alt="img"
                ></p>
<h2 id="Q-amp-A"><a href="#Q-amp-A" class="headerlink" title="Q&amp;A"></a>Q&amp;A</h2><h3 id="java-中应该使用什么数据类型来代表价格-Java-中应该使用什么数据类型来代表价格"><a href="#java-中应该使用什么数据类型来代表价格-Java-中应该使用什么数据类型来代表价格" class="headerlink" title="(java-中应该使用什么数据类型来代表价格) Java 中应该使用什么数据类型来代表价格?"></a>(java-中应该使用什么数据类型来代表价格) Java 中应该使用什么数据类型来代表价格?</h3><p>如果不是特别关心内存和性能的话，使用BigDecimal，否则使用预定义精度的 double 类型。</p>
<h3 id="怎么将-byte-转换为-String"><a href="#怎么将-byte-转换为-String" class="headerlink" title="怎么将 byte 转换为 String?"></a>怎么将 byte 转换为 String?</h3><p>可以使用 String 接收 byte[] 参数的构造器来进行转换，需要注意的点是要使用的正确的编码，否则会使用平台默认编码，这个编码可能跟原来的编码相同，也可能不同。</p>
<h3 id="Java-中怎样将-bytes-转换为-long-类型"><a href="#Java-中怎样将-bytes-转换为-long-类型" class="headerlink" title="Java 中怎样将 bytes 转换为 long 类型?"></a>Java 中怎样将 bytes 转换为 long 类型?</h3><p>String接收bytes的构造器转成String，再Long.parseLong</p>
<h3 id="我们能将-int-强制转换为-byte-类型的变量吗-如果该值大于-byte-类型的范围，将会出现什么现象"><a href="#我们能将-int-强制转换为-byte-类型的变量吗-如果该值大于-byte-类型的范围，将会出现什么现象" class="headerlink" title="我们能将 int 强制转换为 byte 类型的变量吗? 如果该值大于 byte 类型的范围，将会出现什么现象?"></a>我们能将 int 强制转换为 byte 类型的变量吗? 如果该值大于 byte 类型的范围，将会出现什么现象?</h3><p>是的，我们可以做强制转换，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，所以，如果强制转化是，int 类型的高 24 位将会被丢弃，byte 类型的范围是从 -128 到 127。</p>
<h3 id="存在两个类，B-继承-A，C-继承-B，我们能将-B-转换为-C-么-如-C-x3D-C-B；"><a href="#存在两个类，B-继承-A，C-继承-B，我们能将-B-转换为-C-么-如-C-x3D-C-B；" class="headerlink" title="存在两个类，B 继承 A，C 继承 B，我们能将 B 转换为 C 么? 如 C &#x3D; (C) B；"></a>存在两个类，B 继承 A，C 继承 B，我们能将 B 转换为 C 么? 如 C &#x3D; (C) B；</h3><p>可以，向下转型。但是不建议使用，容易出现类型转型异常.</p>
<h3 id="哪个类包含-clone-方法-是-Cloneable-还是-Object"><a href="#哪个类包含-clone-方法-是-Cloneable-还是-Object" class="headerlink" title="哪个类包含 clone 方法? 是 Cloneable 还是 Object?"></a>哪个类包含 clone 方法? 是 Cloneable 还是 Object?</h3><p>java.lang.Cloneable 是一个标示性接口，不包含任何方法，clone 方法在 object 类中定义。并且需要知道 clone() 方法是一个本地方法，这意味着它是由 c 或 c++ 或 其他本地语言实现的。</p>
<h3 id="Java-中-操作符是线程安全的吗"><a href="#Java-中-操作符是线程安全的吗" class="headerlink" title="Java 中 ++ 操作符是线程安全的吗?"></a>Java 中 ++ 操作符是线程安全的吗?</h3><p>不是线程安全的操作。它涉及到多个指令，如读取变量值，增加，然后存储回内存，这个过程可能会出现多个线程交差。还会存在竞态条件(读取-修改-写入)。</p>
<h3 id="a-x3D-a-b-与-a-x3D-b-的区别"><a href="#a-x3D-a-b-与-a-x3D-b-的区别" class="headerlink" title="a &#x3D; a + b 与 a +&#x3D; b 的区别"></a>a &#x3D; a + b 与 a +&#x3D; b 的区别</h3><p>+&#x3D; 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加，如 byte、short 或者 int，首先会将它们提升到 int 类型，然后在执行加法操作。</p>
<p>byte a &#x3D; 127; byte b &#x3D; 127; b &#x3D; a + b; &#x2F;&#x2F; error : cannot convert from int to byte b +&#x3D; a; &#x2F;&#x2F; ok (因为 a+b 操作会将 a、b 提升为 int 类型，所以将 int 类型赋值给 byte 就会编译出错)</p>
<h3 id="我能在不进行强制转换的情况下将一个-double-值赋值给-long-类型的变量吗"><a href="#我能在不进行强制转换的情况下将一个-double-值赋值给-long-类型的变量吗" class="headerlink" title="我能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗?"></a>我能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗?</h3><p>不行，你不能在没有强制类型转换的前提下将一个 double 值赋值给 long 类型的变量，因为 double 类型的范围比 long 类型更广，所以必须要进行强制转换。</p>
<h3 id="3-0-1-x3D-x3D-0-3-将会返回什么-true-还是-false"><a href="#3-0-1-x3D-x3D-0-3-将会返回什么-true-还是-false" class="headerlink" title="3*0.1 &#x3D;&#x3D; 0.3 将会返回什么? true 还是 false?"></a>3*0.1 &#x3D;&#x3D; 0.3 将会返回什么? true 还是 false?</h3><p>false，因为有些浮点数不能完全精确的表示出来。</p>
<h3 id="int-和-Integer-哪个会占用更多的内存"><a href="#int-和-Integer-哪个会占用更多的内存" class="headerlink" title="int 和 Integer 哪个会占用更多的内存?"></a>int 和 Integer 哪个会占用更多的内存?</h3><p>Integer 对象会占用更多的内存。Integer 是一个对象，需要存储对象的元数据。但是 int 是一个原始类型的数据，所以占用的空间更少。</p>
<h3 id="为什么-Java-中的-String-是不可变的-Immutable"><a href="#为什么-Java-中的-String-是不可变的-Immutable" class="headerlink" title="为什么 Java 中的 String 是不可变的(Immutable)?"></a>为什么 Java 中的 String 是不可变的(Immutable)?</h3><p>Java 中的 String 不可变是因为 Java 的设计者认为字符串使用非常频繁，将字符串设置为不可变可以允许多个客户端之间共享相同的字符串。更详细的内容参见答案。</p>
<h3 id="我们能在-Switch-中使用-String-吗"><a href="#我们能在-Switch-中使用-String-吗" class="headerlink" title="我们能在 Switch 中使用 String 吗?"></a>我们能在 Switch 中使用 String 吗?</h3><p>从 Java 7 开始，我们可以在 switch case 中使用字符串，但这仅仅是一个语法糖。内部实现在 switch 中使用字符串的 hash code。</p>
<h3 id="Java-中的构造器链是什么"><a href="#Java-中的构造器链是什么" class="headerlink" title="Java 中的构造器链是什么?"></a>Java 中的构造器链是什么?</h3><p>当你从一个构造器中调用另一个构造器，就是Java 中的构造器链。这种情况只在重载了类的构造器的时候才会出现。</p>
<h3 id="枚举类"><a href="#枚举类" class="headerlink" title="枚举类"></a>枚举类</h3><p>JDK1.5出现 每个枚举值都需要调用一次构造函数</p>
<h3 id="什么是不可变对象-immutable-object-Java-中怎么创建一个不可变对象"><a href="#什么是不可变对象-immutable-object-Java-中怎么创建一个不可变对象" class="headerlink" title="什么是不可变对象(immutable object)? Java 中怎么创建一个不可变对象?"></a>什么是不可变对象(immutable object)? Java 中怎么创建一个不可变对象?</h3><p>不可变对象指对象一旦被创建，状态就不能再改变。任何修改都会创建一个新的对象，如 String、Integer及其它包装类。</p>
<p>如何在Java中写出Immutable的类?</p>
<p>要写出这样的类，需要遵循以下几个原则:</p>
<p>1)immutable对象的状态在创建之后就不能发生改变，任何对它的改变都应该产生一个新的对象。</p>
<p>2)Immutable类的所有的属性都应该是final的。</p>
<p>3)对象必须被正确的创建，比如: 对象引用在对象创建过程中不能泄露(leak)。</p>
<p>4)对象应该是final的，以此来限制子类继承父类，以避免子类改变了父类的immutable特性。</p>
<p>5)如果类中包含mutable类对象，那么返回给客户端的时候，返回该对象的一个拷贝，而不是该对象本身(该条可以归为第一条中的一个特例)</p>
<h3 id="我们能创建一个包含可变对象的不可变对象吗"><a href="#我们能创建一个包含可变对象的不可变对象吗" class="headerlink" title="我们能创建一个包含可变对象的不可变对象吗?"></a>我们能创建一个包含可变对象的不可变对象吗?</h3><p>是的，我们是可以创建一个包含可变对象的不可变对象的，你只需要谨慎一点，不要共享可变对象的引用就可以了，如果需要变化时，就返回原对象的一个拷贝。最常见的例子就是对象中包含一个日期对象的引用。</p>
<h3 id="有没有可能两个不相等的对象有有相同的-hashcode"><a href="#有没有可能两个不相等的对象有有相同的-hashcode" class="headerlink" title="有没有可能两个不相等的对象有有相同的 hashcode?"></a>有没有可能两个不相等的对象有有相同的 hashcode?</h3><p>有可能，两个不相等的对象可能会有相同的 hashcode 值，这就是为什么在 hashmap 中会有冲突。相等 hashcode 值的规定只是说如果两个对象相等，必须有相同的hashcode 值，但是没有关于不相等对象的任何规定。</p>
<h3 id="两个相同的对象会有不同的的-hash-code-吗"><a href="#两个相同的对象会有不同的的-hash-code-吗" class="headerlink" title="两个相同的对象会有不同的的 hash code 吗?"></a>两个相同的对象会有不同的的 hash code 吗?</h3><p>不能，根据 hash code 的规定，这是不可能的。</p>
<h3 id="我们可以在-hashcode-中使用随机数字吗"><a href="#我们可以在-hashcode-中使用随机数字吗" class="headerlink" title="我们可以在 hashcode() 中使用随机数字吗?"></a>我们可以在 hashcode() 中使用随机数字吗?</h3><p>不行，因为对象的 hashcode 值必须是相同的。</p>
<h3 id="Java-中，Comparator-与-Comparable-有什么不同"><a href="#Java-中，Comparator-与-Comparable-有什么不同" class="headerlink" title="Java 中，Comparator 与 Comparable 有什么不同?"></a>Java 中，Comparator 与 Comparable 有什么不同?</h3><p>Comparable 接口用于定义对象的自然顺序，而 comparator 通常用于定义用户定制的顺序。Comparable 总是只有一个，但是可以有多个 comparator 来定义对象的顺序。</p>
<h3 id="为什么在重写-equals-方法的时候需要重写-hashCode-方法"><a href="#为什么在重写-equals-方法的时候需要重写-hashCode-方法" class="headerlink" title="为什么在重写 equals 方法的时候需要重写 hashCode 方法?"></a>为什么在重写 equals 方法的时候需要重写 hashCode 方法?</h3><p>因为有强制的规范指定需要同时重写 hashcode 与 equal 是方法，许多容器类，如 HashMap、HashSet 都依赖于 hashcode 与 equals 的规定。</p>
<h3 id="“a-x3D-x3D-b”和”a-equals-b-”有什么区别"><a href="#“a-x3D-x3D-b”和”a-equals-b-”有什么区别" class="headerlink" title="“a&#x3D;&#x3D;b”和”a.equals(b)”有什么区别?"></a>“a&#x3D;&#x3D;b”和”a.equals(b)”有什么区别?</h3><p>如果 a 和 b 都是对象，则 a&#x3D;&#x3D;b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。</p>
<h3 id="a-hashCode-有什么用-与-a-equals-b-有什么关系"><a href="#a-hashCode-有什么用-与-a-equals-b-有什么关系" class="headerlink" title="a.hashCode() 有什么用? 与 a.equals(b) 有什么关系?"></a>a.hashCode() 有什么用? 与 a.equals(b) 有什么关系?</h3><p>简介: hashCode() 方法是相应对象整型的 hash 值。它常用于基于 hash 的集合类，如 Hashtable、HashMap、LinkedHashMap等等。它与 equals() 方法关系特别紧密。根据 Java 规范，两个使用 equal() 方法来判断相等的对象，必须具有相同的 hash code。</p>
<p>1、hashcode的作用</p>
<p>List和Set，如何保证Set不重复呢? 通过迭代使用equals方法来判断，数据量小还可以接受，数据量大怎么解决? 引入hashcode，实际上hashcode扮演的角色就是寻址，大大减少查询匹配次数。</p>
<p>2、hashcode重要吗</p>
<p>对于数组、List集合就是一个累赘。而对于hashmap, hashset, hashtable就异常重要了。</p>
<p>3、equals方法遵循的原则</p>
<p>对称性 若x.equals(y)true，则y.equals(x)true 自反性 x.equals(x)必须true 传递性 若x.equals(y)true,y.equals(z)true,则x.equals(z)必为true 一致性 只要x,y内容不变，无论调用多少次结果不变 其他 x.equals(null) 永远false，x.equals(和x数据类型不同)始终false 两者的关系</p>
<h3 id="final、finalize-和-finally-的不同之处"><a href="#final、finalize-和-finally-的不同之处" class="headerlink" title="final、finalize 和 finally 的不同之处?"></a>final、finalize 和 finally 的不同之处?</h3><p>final 是一个修饰符，可以修饰变量、方法和类。如果 final 修饰变量，意味着该变量的值在初始化后不能被改变。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的，但是什么时候调用 finalize 没有保证。finally 是一个关键字，与 try 和 catch 一起用于异常的处理。finally 块一定会被执行，无论在 try 块中是否有发生异常。</p>
<h3 id="Java-中的编译期常量是什么-使用它又什么风险"><a href="#Java-中的编译期常量是什么-使用它又什么风险" class="headerlink" title="Java 中的编译期常量是什么? 使用它又什么风险?"></a>Java 中的编译期常量是什么? 使用它又什么风险?</h3><p>变量也就是我们所说的编译期常量，这里的 public 可选的。实际上这些变量在编译时会被替换掉，因为编译器知道这些变量的值，并且知道这些变量在运行时不能改变。这种方式存在的一个问题是你使用了一个内部的或第三方库中的公有编译时常量，但是这个值后面被其他人改变了，但是你的客户端仍然在使用老的值，甚至你已经部署了一个新的jar。为了避免这种情况，当你在更新依赖 JAR 文件时，确保重新编译你的程序。</p>
<h3 id="静态内部类与顶级类有什么区别"><a href="#静态内部类与顶级类有什么区别" class="headerlink" title="静态内部类与顶级类有什么区别?"></a>静态内部类与顶级类有什么区别?</h3><p>一个公共的顶级类的源文件名称与类名相同，而嵌套静态类没有这个要求。一个嵌套类位于顶级类内部，需要使用顶级类的名称来引用嵌套静态类，如 HashMap.Entry 是一个嵌套静态类，HashMap 是一个顶级类，Entry是一个嵌套静态类。</p>
<h3 id="Java-中，Serializable-与-Externalizable-的区别"><a href="#Java-中，Serializable-与-Externalizable-的区别" class="headerlink" title="Java 中，Serializable 与 Externalizable 的区别?"></a>Java 中，Serializable 与 Externalizable 的区别?</h3><p>Serializable 接口是一个序列化 Java 类的接口，以便于它们可以在网络上传输或者可以将它们的状态保存在磁盘上，是 JVM 内嵌的默认序列化方式，成本高、脆弱而且不安全。Externalizable 允许你控制整个序列化过程，指定特定的二进制格式，增加安全机制。</p>
<h3 id="说出-JDK-1-7-中的三个新特性"><a href="#说出-JDK-1-7-中的三个新特性" class="headerlink" title="说出 JDK 1.7 中的三个新特性?"></a>说出 JDK 1.7 中的三个新特性?</h3><p>虽然 JDK 1.7 不像 JDK 5 和 8 一样的大版本，但是，还是有很多新的特性，如 try-with-resource 语句，这样你在使用流或者资源的时候，就不需要手动关闭，Java 会自动关闭。Fork-Join 池某种程度上实现 Java 版的 Map-reduce。允许 Switch 中有 String 变量和文本。菱形操作符(&lt;&gt;)用于泛型推断，不再需要在变量声明的右边申明泛型，因此可以写出可读写更强、更简洁的代码。另一个值得一提的特性是改善异常处理，如允许在同一个 catch 块中捕获多个异常。</p>
<h3 id="说出-5-个-JDK-1-8-引入的新特性"><a href="#说出-5-个-JDK-1-8-引入的新特性" class="headerlink" title="说出 5 个 JDK 1.8 引入的新特性?"></a>说出 5 个 JDK 1.8 引入的新特性?</h3><p>Java 8 在 Java 历史上是一个开创新的版本，下面 JDK 8 中 5 个主要的特性: Lambda 表达式，允许像对象一样传递匿名函数 Stream API，充分利用现代多核 CPU，可以写出很简洁的代码 Date 与 Time API，最终，有一个稳定、简单的日期和时间库可供你使用 扩展方法，现在，接口中可以有静态、默认方法。 重复注解，现在你可以将相同的注解在同一类型上使用多次。</p>
<p>下述包含 Java 面试过程中关于 SOLID 的设计原则，OOP 基础，如类，对象，接口，继承，多态，封装，抽象以及更高级的一些概念，如组合、聚合及关联。也包含了 GOF 设计模式的问题。</p>
<h3 id="接口是什么-为什么要使用接口而不是直接使用具体类"><a href="#接口是什么-为什么要使用接口而不是直接使用具体类" class="headerlink" title="接口是什么? 为什么要使用接口而不是直接使用具体类?"></a>接口是什么? 为什么要使用接口而不是直接使用具体类?</h3><p>接口用于定义 API。它定义了类必须得遵循的规则。同时，它提供了一种抽象，因为客户端只使用接口，这样可以有多重实现，如 List 接口，你可以使用可随机访问的 ArrayList，也可以使用方便插入和删除的 LinkedList。接口中不允许普通方法，以此来保证抽象，但是 Java 8 中你可以在接口声明静态方法和默认普通方法。</p>
<h3 id="Java-中，抽象类与接口之间有什么不同"><a href="#Java-中，抽象类与接口之间有什么不同" class="headerlink" title="Java 中，抽象类与接口之间有什么不同?"></a>Java 中，抽象类与接口之间有什么不同?</h3><p>Java 中，抽象类和接口有很多不同之处，但是最重要的一个是 Java 中限制一个类只能继承一个类，但是可以实现多个接口。抽象类可以很好的定义一个家族类的默认行为，而接口能更好的定义类型，有助于后面实现多态机制 参见第六条。</p>
<h3 id="Object有哪些公用方法"><a href="#Object有哪些公用方法" class="headerlink" title="Object有哪些公用方法?"></a>Object有哪些公用方法?</h3><p>clone equals hashcode wait notify notifyall finalize toString getClass 除了clone和finalize其他均为公共方法。</p>
<p>11个方法，wait被重载了两次</p>
<h3 id="equals与-x3D-x3D-的区别"><a href="#equals与-x3D-x3D-的区别" class="headerlink" title="equals与&#x3D;&#x3D;的区别"></a>equals与&#x3D;&#x3D;的区别</h3><p>区别1. &#x3D;&#x3D;是一个运算符 equals是Object类的方法</p>
<p>区别2. 比较时的区别</p>
<p>a. 用于基本类型的变量比较时: &#x3D;&#x3D;用于比较值是否相等，equals不能直接用于基本数据类型的比较，需要转换为其对应的包装类型。 b. 用于引用类型的比较时。&#x3D;&#x3D;和equals都是比较栈内存中的地址是否相等 。相等为true 否则为false。但是通常会重写equals方法去实现对象内容的比较。</p>
<h3 id="String、StringBuffer与StringBuilder的区别"><a href="#String、StringBuffer与StringBuilder的区别" class="headerlink" title="String、StringBuffer与StringBuilder的区别"></a>String、StringBuffer与StringBuilder的区别</h3><p>第一点: 可变和适用范围。String对象是不可变的，而StringBuffer和StringBuilder是可变字符序列。每次对String的操作相当于生成一个新的String对象，而对StringBuffer和StringBuilder的操作是对对象本身的操作，而不会生成新的对象，所以对于频繁改变内容的字符串避免使用String，因为频繁的生成对象将会对系统性能产生影响。</p>
<p>第二点: 线程安全。String由于有final修饰，是immutable的，安全性是简单而纯粹的。StringBuilder和StringBuffer的区别在于StringBuilder不保证同步，也就是说如果需要线程安全需要使用StringBuffer，不需要同步的StringBuilder效率更高。</p>
<h3 id="switch能否用String做参数"><a href="#switch能否用String做参数" class="headerlink" title="switch能否用String做参数"></a>switch能否用String做参数</h3><p>Java1.7开始支持，但实际这是一颗Java语法糖。除此之外，byte，short，long，枚举，boolean均可用于switch，只有浮点型不可以。</p>
<h3 id="接口与抽象类"><a href="#接口与抽象类" class="headerlink" title="接口与抽象类"></a>接口与抽象类</h3><p>6.1 一个子类只能继承一个抽象类,但能实现多个接口 6.2 抽象类可以有构造方法,接口没有构造方法 6.3 抽象类可以有普通成员变量,接口没有普通成员变量 6.4 抽象类和接口都可有静态成员变量,抽象类中静态成员变量访问类型任意，接口只能public static final(默认) 6.5 抽象类可以没有抽象方法,抽象类可以有普通方法,接口中都是抽象方法 6.6 抽象类可以有静态方法，接口不能有静态方法 6.7 抽象类中的方法可以是public、protected;接口方法只有public abstract</p>
<h3 id="抽象类和最终类"><a href="#抽象类和最终类" class="headerlink" title="抽象类和最终类"></a>抽象类和最终类</h3><p>抽象类可以没有抽象方法, 最终类可以没有最终方法</p>
<p>最终类不能被继承, 最终方法不能被重写(可以重载)</p>
<h3 id="异常"><a href="#异常" class="headerlink" title="异常"></a>异常</h3><p>相关的关键字 throw、throws、try…catch、finally</p>
<p>throws 用在方法签名上, 以便抛出的异常可以被调用者处理 throw 方法内部通过throw抛出异常 try 用于检测包住的语句块, 若有异常, catch子句捕获并执行catch块</p>
<h3 id="关于finally"><a href="#关于finally" class="headerlink" title="关于finally"></a>关于finally</h3><p>finally不管有没有异常都要处理 当try和catch中有return时，finally仍然会执行，finally比return先执行 不管有木有异常抛出, finally在return返回前执行 finally是在return后面的表达式运算后执行的(此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值)，所以函数返回值是在finally执行前确定的 注意: finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值</p>
<p>finally不执行的几种情况: 程序提前终止如调用了System.exit, 病毒，断电</p>
<h3 id="受检查异常和运行时异常"><a href="#受检查异常和运行时异常" class="headerlink" title="受检查异常和运行时异常"></a>受检查异常和运行时异常</h3><p>10.1 粉红色的是受检查的异常(checked exceptions),其必须被try…catch语句块所捕获, 或者在方法签名里通过throws子句声明。受检查的异常必须在编译时被捕捉处理,命名为Checked Exception是因为Java编译器要进行检查, Java虚拟机也要进行检查, 以确保这个规则得到遵守。</p>
<p>常见的checked exception: ClassNotFoundException IOException FileNotFoundException EOFException</p>
<p>10.2 绿色的异常是运行时异常(runtime exceptions), 需要程序员自己分析代码决定是否捕获和处理,比如空指针,被0除…</p>
<p>常见的runtime exception: NullPointerException ArithmeticException ClassCastException IllegalArgumentException IllegalStateException IndexOutOfBoundsException NoSuchElementException</p>
<p>10.3 而声明为Error的，则属于严重错误，如系统崩溃、虚拟机错误、动态链接失败等，这些错误无法恢复或者不可能捕捉，将导致应用程序中断，Error不需要捕获。</p>
<h3 id="super出现在父类的子类中。有三种存在方式"><a href="#super出现在父类的子类中。有三种存在方式" class="headerlink" title="super出现在父类的子类中。有三种存在方式"></a>super出现在父类的子类中。有三种存在方式</h3><p>super.xxx(xxx为变量名或对象名)意思是获取父类中xxx的变量或引用 super.xxx(); (xxx为方法名)意思是直接访问并调用父类中的方法 super() 调用父类构造 注: super只能指代其直接父类</p>
<h3 id="this-amp-super-在构造方法中的区别"><a href="#this-amp-super-在构造方法中的区别" class="headerlink" title="this() &amp; super()在构造方法中的区别"></a>this() &amp; super()在构造方法中的区别</h3><p>调用super()必须写在子类构造方法的第一行, 否则编译不通过 super从子类调用父类构造, this在同一类中调用其他构造 均需要放在第一行 尽管可以用this调用一个构造器, 却不能调用2个 this和super不能出现在同一个构造器中, 否则编译不通过 this()、super()都指的对象,不可以在static环境中使用 本质this指向本对象的指针。super是一个关键字</p>
<h3 id="修饰符一览"><a href="#修饰符一览" class="headerlink" title="修饰符一览"></a>修饰符一览</h3><p>修饰符 类内部 同一个包 子类 任何地方 private yes default yes yes protected yes yes yes public yes yes yes yes</p>
<h3 id="构造内部类和静态内部类对象"><a href="#构造内部类和静态内部类对象" class="headerlink" title="构造内部类和静态内部类对象"></a>构造内部类和静态内部类对象</h3><p>public class Enclosingone { public class Insideone {} public static class Insideone{} }</p>
<p>public class Test { public static void main(String[] args) { &#x2F;&#x2F; 构造内部类对象需要外部类的引用 Enclosingone.Insideone obj1 &#x3D; new Enclosingone().new Insideone(); &#x2F;&#x2F; 构造静态内部类的对象 Enclosingone.Insideone obj2 &#x3D; new Enclosingone.Insideone(); } } 静态内部类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。非静态内部类能够访问外部类的静态和非静态成员。静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员。</p>
<h3 id="序列化"><a href="#序列化" class="headerlink" title="序列化"></a>序列化</h3><p>声明为static和transient类型的数据不能被序列化， 反序列化需要一个无参构造函数</p>
<p>序列化参见我的笔记Java-note-序列化.md</p>
<h3 id="正则表达式"><a href="#正则表达式" class="headerlink" title="正则表达式"></a>正则表达式</h3><p>次数符号</p>
<ul>
<li>0或多次</li>
<li>1或多次 ? 0或1次 {n} 恰n次 {n,m} 从n到m次 其他符号</li>
</ul>
<p>符号 等价形式</p>
<p>\d [0-9] \D [^0-9]<br>\w [a-zA-Z_0-9] \W [^a-zA-Z_0-9] \s [\t\n\r\f] \S [^\t\n\r\f] . 任何字符 边界匹配器</p>
<p>行开头 ^ 行结尾 $ 单词边界 \b</p>
<p>贪婪模式:最大长度匹配 非贪婪模式:匹配到结果就好,最短匹配</p>
<p>环视</p>
<p>字符 描述 匹配对象 . 单个任意字符 […] 字符组 列出的任意字符 [^…] 未列出的任意字符 ^ caret 行的起始位置 $ dollar 行的结束位置 &lt; 单词的起始位置 &gt; 单词的结束位置 \b 单词边界 \B 非单词边界 (?&#x3D;Expression) 顺序肯定环视 成功,如果右边能够匹配 (?!Expression) 顺序否定环视 成功,如果右边不能够匹配 (?&lt;&#x3D;Expression) 逆序肯定环视 成功,如果左边能够匹配 (?&lt;!Expression) 逆序否定环视 成功,如果左边不能够匹配 举例:北京市(海淀区)(朝阳区)(西城区)</p>
<p>Regex: .*(?&#x3D;()</p>
<p>模式和匹配器的典型调用次序</p>
<p>把正则表达式编译到模式中 Pattern p &#x3D; Pattern.compile(“a*b”); 创建给定输入与此模式的匹配器 Matcher m &#x3D; p.matcher(“aaab”); 尝试将整个区域与此模式匹配 boolean b &#x3D; m.matches();</p>
<ol>
<li>null可以被强制转型为任意类型的对象</li>
</ol>
<p>19.代码执行次序</p>
<p>多个静态成员变量, 静态代码块按顺序执行 单个类中: 静态代码 -&gt; main方法 -&gt; 构造块 -&gt; 构造方法 构造块在每一次创建对象时执行 涉及父类和子类的初始化过程 a.初始化父类中的静态成员变量和静态代码块 b.初始化子类中的静态成员变量和静态代码块 c.初始化父类的普通成员变量和构造代码块(按次序)，再执行父类的构造方法(注意父类构造方法中的子类方法覆盖) d.初始化子类的普通成员变量和构造代码块(按次序)，再执行子类的构造方法 20. 数组复制方法</p>
<p>for逐一复制 System.arraycopy() -&gt; 效率最高native方法 Arrays.copyOf() -&gt; 本质调用arraycopy clone方法 -&gt; 返回Object[],需要强制类型转换 21. 多态</p>
<p>Java通过方法重写和方法重载实现多态 方法重写是指子类重写了父类的同名方法 方法重载是指在同一个类中，方法的名字相同，但是参数列表不同 22. Java文件</p>
<p>.java文件可以包含多个类，唯一的限制就是: 一个文件中只能有一个public类， 并且此public类必须与 文件名相同。而且这些类和写在多个文件中没有区别。</p>
<h3 id="Java移位运算符"><a href="#Java移位运算符" class="headerlink" title="Java移位运算符"></a>Java移位运算符</h3><p>java中有三种移位运算符</p>
<p>&lt;&lt; :左移运算符,x &lt;&lt; 1,相当于x乘以2(不溢出的情况下),低位补0</p>
<blockquote>
<blockquote>
<p>:带符号右移,x &gt;&gt; 1,相当于x除以2,正数高位补0,负数高位补1</p>
<blockquote>
<p>:无符号右移,忽略符号位,空位都以0补齐 参见我的GitHub，Java移位符</p>
</blockquote>
</blockquote>
</blockquote>
<h3 id="形参-amp-实参"><a href="#形参-amp-实参" class="headerlink" title="形参&amp;实参"></a>形参&amp;实参</h3><p>形式参数可被视为local variable.形参和局部变量一样都不能离开方法。只有在方法中使用，不会在方法外可见。 形式参数只能用final修饰符，其它任何修饰符都会引起编译器错误。但是用这个修饰符也有一定的限制，就是在方法中不能对参数做任何修改。不过一般情况下，一个方法的形参不用final修饰。只有在特殊情况下，那就是: 方法内部类。一个方法内的内部类如果使用了这个方法的参数或者局部变量的话，这个参数或局部变量应该是final。 形参的值在调用时根据调用者更改，实参则用自身的值更改形参的值(指针、引用皆在此列)，也就是说真正被传递的是实参。</p>
<h3 id="局部变量为什么要初始化"><a href="#局部变量为什么要初始化" class="headerlink" title="局部变量为什么要初始化"></a>局部变量为什么要初始化</h3><p>局部变量是指类方法中的变量，必须初始化。局部变量运行时被分配在栈中，量大，生命周期短，如果虚拟机给每个局部变量都初始化一下，是一笔很大的开销，但变量不初始化为默认值就使用是不安全的。出于速度和安全性两个方面的综合考虑，解决方案就是虚拟机不初始化，但要求编写者一定要在使用前给变量赋值。</p>
<h3 id="Java语言的鲁棒性"><a href="#Java语言的鲁棒性" class="headerlink" title="Java语言的鲁棒性"></a>Java语言的鲁棒性</h3><p>Java在编译和运行程序时，都要对可能出现的问题进行检查，以消除错误的产生。它提供自动垃圾收集来进行内存管理，防止程序员在管理内存时容易产生的错误。通过集成的面向对象的例外处理机制，在编译时，Java揭示出可能出现但未被处理的异常，帮助程序员正确地进行选择以防止系统的崩溃。另外，Java在编译时还可捕获类型声明中的许多常见错误，防止动态运行时不匹配问题的出现。</p>
<h3 id="Java语言特性"><a href="#Java语言特性" class="headerlink" title="Java语言特性"></a>Java语言特性</h3><p>Java致力于检查程序在编译和运行时的错误 Java虚拟机实现了跨平台接口 类型检查帮助检查出许多开发早期出现的错误 Java自己操纵内存减少了内存出错的可能性 Java还实现了真数组，避免了覆盖数据的可能</p>
<h3 id="包装类的equals-方法不处理数据转型，必须类型和值都一样才相等。"><a href="#包装类的equals-方法不处理数据转型，必须类型和值都一样才相等。" class="headerlink" title="包装类的equals()方法不处理数据转型，必须类型和值都一样才相等。"></a>包装类的equals()方法不处理数据转型，必须类型和值都一样才相等。</h3><h3 id="子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。"><a href="#子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。" class="headerlink" title="子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。"></a>子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。</h3><h3 id="Java语法糖"><a href="#Java语法糖" class="headerlink" title="Java语法糖"></a>Java语法糖</h3><p>Java7的switch用字符串 - hashcode方法 switch用于enum枚举 伪泛型 - List原始类型 自动装箱拆箱 - Integer.valueOf和Integer.intValue foreach遍历 - Iterator迭代器实现 条件编译 enum枚举类、内部类 可变参数 - 数组 断言语言 try语句中定义和关闭资源</p>

            </div>

            
                <div class="post-copyright-info">
                    
<div class="article-copyright-info-container">
    <ul class="copyright-info-content">
        <li class="post-title">
            <span class="type">本文标题</span>：<span class="content">Java基础-图谱&amp;Q/A</span>
        </li>
        <li class="post-author">
            <span class="type">本文作者</span>：<span class="content">Blank</span>
        </li>
        <li class="post-time">
            <span class="type">创建时间</span>：<span class="content">2023-02-21 00:51:18</span>
        </li>
        <li class="post-link">
            <span class="type">本文链接</span>：<span class="content">2023/02/21/Java 基础-图谱&amp;QA/</span>
        </li>
        <li class="post-license">
            <span class="type">版权声明</span>：<span class="content">本博客所有文章除特别声明外，均采用 <a class="license" target="_blank" rel="noopener" href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh">BY-NC-SA</a> 许可协议。转载请注明出处！</span>
        </li>
    </ul>
    <div class="copy-copyright-info flex-center tooltip" data-content="复制版权信息" data-offset-y="-2px">
        <i class="fa-solid fa-copy"></i>
    </div>
</div>

                </div>
            

            
                <ul class="post-tags-box">
                    
                        <li class="tag-item">
                            <a href="/tags/Java/">#Java</a>&nbsp;
                        </li>
                    
                </ul>
            

            
                <div class="article-nav">
                    
                        <div class="article-prev">
                            <a class="prev"
                               rel="prev"
                               href="/2023/02/21/Java%20%E5%9F%BA%E7%A1%80-%E7%9F%A5%E8%AF%86%E7%82%B9/"
                            >
                            <span class="left arrow-icon flex-center">
                              <i class="fas fa-chevron-left"></i>
                            </span>
                                <span class="title flex-center">
                                <span class="post-nav-title-item">Java基础-知识点</span>
                                <span class="post-nav-item">上一篇</span>
                            </span>
                            </a>
                        </div>
                    
                    
                        <div class="article-next">
                            <a class="next"
                               rel="next"
                               href="/2023/02/21/Docker/"
                            >
                            <span class="title flex-center">
                                <span class="post-nav-title-item">Docker</span>
                                <span class="post-nav-item">下一篇</span>
                            </span>
                                <span class="right arrow-icon flex-center">
                              <i class="fas fa-chevron-right"></i>
                            </span>
                            </a>
                        </div>
                    
                </div>
            

            
        </div>

        
            <div class="toc-content-container">
                <div class="post-toc-wrap">
    <div class="post-toc">
        <ol class="nav"><li class="nav-item nav-level-1"><a class="nav-link" href="#java-%E5%9F%BA%E7%A1%80-%E5%9B%BE%E8%B0%B1-amp-Q-x2F-A"><span class="nav-number">1.</span> <span class="nav-text">java 基础-图谱&amp;Q&#x2F;A</span></a><ol class="nav-child"><li class="nav-item nav-level-2"><a class="nav-link" href="#%E5%8F%82%E8%80%83%E6%96%87%E6%A1%A3"><span class="nav-number">1.1.</span> <span class="nav-text">参考文档</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E7%9F%A5%E8%AF%86%E4%BD%93%E7%B3%BB"><span class="nav-number">1.2.</span> <span class="nav-text">知识体系</span></a></li><li class="nav-item nav-level-2"><a class="nav-link" href="#Q-amp-A"><span class="nav-number">1.3.</span> <span class="nav-text">Q&amp;A</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#java-%E4%B8%AD%E5%BA%94%E8%AF%A5%E4%BD%BF%E7%94%A8%E4%BB%80%E4%B9%88%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9D%A5%E4%BB%A3%E8%A1%A8%E4%BB%B7%E6%A0%BC-Java-%E4%B8%AD%E5%BA%94%E8%AF%A5%E4%BD%BF%E7%94%A8%E4%BB%80%E4%B9%88%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B%E6%9D%A5%E4%BB%A3%E8%A1%A8%E4%BB%B7%E6%A0%BC"><span class="nav-number">1.3.1.</span> <span class="nav-text">(java-中应该使用什么数据类型来代表价格) Java 中应该使用什么数据类型来代表价格?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%80%8E%E4%B9%88%E5%B0%86-byte-%E8%BD%AC%E6%8D%A2%E4%B8%BA-String"><span class="nav-number">1.3.2.</span> <span class="nav-text">怎么将 byte 转换为 String?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD%E6%80%8E%E6%A0%B7%E5%B0%86-bytes-%E8%BD%AC%E6%8D%A2%E4%B8%BA-long-%E7%B1%BB%E5%9E%8B"><span class="nav-number">1.3.3.</span> <span class="nav-text">Java 中怎样将 bytes 转换为 long 类型?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%88%91%E4%BB%AC%E8%83%BD%E5%B0%86-int-%E5%BC%BA%E5%88%B6%E8%BD%AC%E6%8D%A2%E4%B8%BA-byte-%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%8F%98%E9%87%8F%E5%90%97-%E5%A6%82%E6%9E%9C%E8%AF%A5%E5%80%BC%E5%A4%A7%E4%BA%8E-byte-%E7%B1%BB%E5%9E%8B%E7%9A%84%E8%8C%83%E5%9B%B4%EF%BC%8C%E5%B0%86%E4%BC%9A%E5%87%BA%E7%8E%B0%E4%BB%80%E4%B9%88%E7%8E%B0%E8%B1%A1"><span class="nav-number">1.3.4.</span> <span class="nav-text">我们能将 int 强制转换为 byte 类型的变量吗? 如果该值大于 byte 类型的范围，将会出现什么现象?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%AD%98%E5%9C%A8%E4%B8%A4%E4%B8%AA%E7%B1%BB%EF%BC%8CB-%E7%BB%A7%E6%89%BF-A%EF%BC%8CC-%E7%BB%A7%E6%89%BF-B%EF%BC%8C%E6%88%91%E4%BB%AC%E8%83%BD%E5%B0%86-B-%E8%BD%AC%E6%8D%A2%E4%B8%BA-C-%E4%B9%88-%E5%A6%82-C-x3D-C-B%EF%BC%9B"><span class="nav-number">1.3.5.</span> <span class="nav-text">存在两个类，B 继承 A，C 继承 B，我们能将 B 转换为 C 么? 如 C &#x3D; (C) B；</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%93%AA%E4%B8%AA%E7%B1%BB%E5%8C%85%E5%90%AB-clone-%E6%96%B9%E6%B3%95-%E6%98%AF-Cloneable-%E8%BF%98%E6%98%AF-Object"><span class="nav-number">1.3.6.</span> <span class="nav-text">哪个类包含 clone 方法? 是 Cloneable 还是 Object?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD-%E6%93%8D%E4%BD%9C%E7%AC%A6%E6%98%AF%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E7%9A%84%E5%90%97"><span class="nav-number">1.3.7.</span> <span class="nav-text">Java 中 ++ 操作符是线程安全的吗?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#a-x3D-a-b-%E4%B8%8E-a-x3D-b-%E7%9A%84%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.8.</span> <span class="nav-text">a &#x3D; a + b 与 a +&#x3D; b 的区别</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%88%91%E8%83%BD%E5%9C%A8%E4%B8%8D%E8%BF%9B%E8%A1%8C%E5%BC%BA%E5%88%B6%E8%BD%AC%E6%8D%A2%E7%9A%84%E6%83%85%E5%86%B5%E4%B8%8B%E5%B0%86%E4%B8%80%E4%B8%AA-double-%E5%80%BC%E8%B5%8B%E5%80%BC%E7%BB%99-long-%E7%B1%BB%E5%9E%8B%E7%9A%84%E5%8F%98%E9%87%8F%E5%90%97"><span class="nav-number">1.3.9.</span> <span class="nav-text">我能在不进行强制转换的情况下将一个 double 值赋值给 long 类型的变量吗?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#3-0-1-x3D-x3D-0-3-%E5%B0%86%E4%BC%9A%E8%BF%94%E5%9B%9E%E4%BB%80%E4%B9%88-true-%E8%BF%98%E6%98%AF-false"><span class="nav-number">1.3.10.</span> <span class="nav-text">3*0.1 &#x3D;&#x3D; 0.3 将会返回什么? true 还是 false?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#int-%E5%92%8C-Integer-%E5%93%AA%E4%B8%AA%E4%BC%9A%E5%8D%A0%E7%94%A8%E6%9B%B4%E5%A4%9A%E7%9A%84%E5%86%85%E5%AD%98"><span class="nav-number">1.3.11.</span> <span class="nav-text">int 和 Integer 哪个会占用更多的内存?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88-Java-%E4%B8%AD%E7%9A%84-String-%E6%98%AF%E4%B8%8D%E5%8F%AF%E5%8F%98%E7%9A%84-Immutable"><span class="nav-number">1.3.12.</span> <span class="nav-text">为什么 Java 中的 String 是不可变的(Immutable)?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%88%91%E4%BB%AC%E8%83%BD%E5%9C%A8-Switch-%E4%B8%AD%E4%BD%BF%E7%94%A8-String-%E5%90%97"><span class="nav-number">1.3.13.</span> <span class="nav-text">我们能在 Switch 中使用 String 吗?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD%E7%9A%84%E6%9E%84%E9%80%A0%E5%99%A8%E9%93%BE%E6%98%AF%E4%BB%80%E4%B9%88"><span class="nav-number">1.3.14.</span> <span class="nav-text">Java 中的构造器链是什么?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%9E%9A%E4%B8%BE%E7%B1%BB"><span class="nav-number">1.3.15.</span> <span class="nav-text">枚举类</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E4%BB%80%E4%B9%88%E6%98%AF%E4%B8%8D%E5%8F%AF%E5%8F%98%E5%AF%B9%E8%B1%A1-immutable-object-Java-%E4%B8%AD%E6%80%8E%E4%B9%88%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E4%B8%8D%E5%8F%AF%E5%8F%98%E5%AF%B9%E8%B1%A1"><span class="nav-number">1.3.16.</span> <span class="nav-text">什么是不可变对象(immutable object)? Java 中怎么创建一个不可变对象?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%88%91%E4%BB%AC%E8%83%BD%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA%E5%8C%85%E5%90%AB%E5%8F%AF%E5%8F%98%E5%AF%B9%E8%B1%A1%E7%9A%84%E4%B8%8D%E5%8F%AF%E5%8F%98%E5%AF%B9%E8%B1%A1%E5%90%97"><span class="nav-number">1.3.17.</span> <span class="nav-text">我们能创建一个包含可变对象的不可变对象吗?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%9C%89%E6%B2%A1%E6%9C%89%E5%8F%AF%E8%83%BD%E4%B8%A4%E4%B8%AA%E4%B8%8D%E7%9B%B8%E7%AD%89%E7%9A%84%E5%AF%B9%E8%B1%A1%E6%9C%89%E6%9C%89%E7%9B%B8%E5%90%8C%E7%9A%84-hashcode"><span class="nav-number">1.3.18.</span> <span class="nav-text">有没有可能两个不相等的对象有有相同的 hashcode?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E4%B8%A4%E4%B8%AA%E7%9B%B8%E5%90%8C%E7%9A%84%E5%AF%B9%E8%B1%A1%E4%BC%9A%E6%9C%89%E4%B8%8D%E5%90%8C%E7%9A%84%E7%9A%84-hash-code-%E5%90%97"><span class="nav-number">1.3.19.</span> <span class="nav-text">两个相同的对象会有不同的的 hash code 吗?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%88%91%E4%BB%AC%E5%8F%AF%E4%BB%A5%E5%9C%A8-hashcode-%E4%B8%AD%E4%BD%BF%E7%94%A8%E9%9A%8F%E6%9C%BA%E6%95%B0%E5%AD%97%E5%90%97"><span class="nav-number">1.3.20.</span> <span class="nav-text">我们可以在 hashcode() 中使用随机数字吗?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD%EF%BC%8CComparator-%E4%B8%8E-Comparable-%E6%9C%89%E4%BB%80%E4%B9%88%E4%B8%8D%E5%90%8C"><span class="nav-number">1.3.21.</span> <span class="nav-text">Java 中，Comparator 与 Comparable 有什么不同?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E4%B8%BA%E4%BB%80%E4%B9%88%E5%9C%A8%E9%87%8D%E5%86%99-equals-%E6%96%B9%E6%B3%95%E7%9A%84%E6%97%B6%E5%80%99%E9%9C%80%E8%A6%81%E9%87%8D%E5%86%99-hashCode-%E6%96%B9%E6%B3%95"><span class="nav-number">1.3.22.</span> <span class="nav-text">为什么在重写 equals 方法的时候需要重写 hashCode 方法?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E2%80%9Ca-x3D-x3D-b%E2%80%9D%E5%92%8C%E2%80%9Da-equals-b-%E2%80%9D%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.23.</span> <span class="nav-text">“a&#x3D;&#x3D;b”和”a.equals(b)”有什么区别?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#a-hashCode-%E6%9C%89%E4%BB%80%E4%B9%88%E7%94%A8-%E4%B8%8E-a-equals-b-%E6%9C%89%E4%BB%80%E4%B9%88%E5%85%B3%E7%B3%BB"><span class="nav-number">1.3.24.</span> <span class="nav-text">a.hashCode() 有什么用? 与 a.equals(b) 有什么关系?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#final%E3%80%81finalize-%E5%92%8C-finally-%E7%9A%84%E4%B8%8D%E5%90%8C%E4%B9%8B%E5%A4%84"><span class="nav-number">1.3.25.</span> <span class="nav-text">final、finalize 和 finally 的不同之处?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD%E7%9A%84%E7%BC%96%E8%AF%91%E6%9C%9F%E5%B8%B8%E9%87%8F%E6%98%AF%E4%BB%80%E4%B9%88-%E4%BD%BF%E7%94%A8%E5%AE%83%E5%8F%88%E4%BB%80%E4%B9%88%E9%A3%8E%E9%99%A9"><span class="nav-number">1.3.26.</span> <span class="nav-text">Java 中的编译期常量是什么? 使用它又什么风险?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E9%9D%99%E6%80%81%E5%86%85%E9%83%A8%E7%B1%BB%E4%B8%8E%E9%A1%B6%E7%BA%A7%E7%B1%BB%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.27.</span> <span class="nav-text">静态内部类与顶级类有什么区别?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD%EF%BC%8CSerializable-%E4%B8%8E-Externalizable-%E7%9A%84%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.28.</span> <span class="nav-text">Java 中，Serializable 与 Externalizable 的区别?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E8%AF%B4%E5%87%BA-JDK-1-7-%E4%B8%AD%E7%9A%84%E4%B8%89%E4%B8%AA%E6%96%B0%E7%89%B9%E6%80%A7"><span class="nav-number">1.3.29.</span> <span class="nav-text">说出 JDK 1.7 中的三个新特性?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E8%AF%B4%E5%87%BA-5-%E4%B8%AA-JDK-1-8-%E5%BC%95%E5%85%A5%E7%9A%84%E6%96%B0%E7%89%B9%E6%80%A7"><span class="nav-number">1.3.30.</span> <span class="nav-text">说出 5 个 JDK 1.8 引入的新特性?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%8E%A5%E5%8F%A3%E6%98%AF%E4%BB%80%E4%B9%88-%E4%B8%BA%E4%BB%80%E4%B9%88%E8%A6%81%E4%BD%BF%E7%94%A8%E6%8E%A5%E5%8F%A3%E8%80%8C%E4%B8%8D%E6%98%AF%E7%9B%B4%E6%8E%A5%E4%BD%BF%E7%94%A8%E5%85%B7%E4%BD%93%E7%B1%BB"><span class="nav-number">1.3.31.</span> <span class="nav-text">接口是什么? 为什么要使用接口而不是直接使用具体类?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java-%E4%B8%AD%EF%BC%8C%E6%8A%BD%E8%B1%A1%E7%B1%BB%E4%B8%8E%E6%8E%A5%E5%8F%A3%E4%B9%8B%E9%97%B4%E6%9C%89%E4%BB%80%E4%B9%88%E4%B8%8D%E5%90%8C"><span class="nav-number">1.3.32.</span> <span class="nav-text">Java 中，抽象类与接口之间有什么不同?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Object%E6%9C%89%E5%93%AA%E4%BA%9B%E5%85%AC%E7%94%A8%E6%96%B9%E6%B3%95"><span class="nav-number">1.3.33.</span> <span class="nav-text">Object有哪些公用方法?</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#equals%E4%B8%8E-x3D-x3D-%E7%9A%84%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.34.</span> <span class="nav-text">equals与&#x3D;&#x3D;的区别</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#String%E3%80%81StringBuffer%E4%B8%8EStringBuilder%E7%9A%84%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.35.</span> <span class="nav-text">String、StringBuffer与StringBuilder的区别</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#switch%E8%83%BD%E5%90%A6%E7%94%A8String%E5%81%9A%E5%8F%82%E6%95%B0"><span class="nav-number">1.3.36.</span> <span class="nav-text">switch能否用String做参数</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%8E%A5%E5%8F%A3%E4%B8%8E%E6%8A%BD%E8%B1%A1%E7%B1%BB"><span class="nav-number">1.3.37.</span> <span class="nav-text">接口与抽象类</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%8A%BD%E8%B1%A1%E7%B1%BB%E5%92%8C%E6%9C%80%E7%BB%88%E7%B1%BB"><span class="nav-number">1.3.38.</span> <span class="nav-text">抽象类和最终类</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%BC%82%E5%B8%B8"><span class="nav-number">1.3.39.</span> <span class="nav-text">异常</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%85%B3%E4%BA%8Efinally"><span class="nav-number">1.3.40.</span> <span class="nav-text">关于finally</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%8F%97%E6%A3%80%E6%9F%A5%E5%BC%82%E5%B8%B8%E5%92%8C%E8%BF%90%E8%A1%8C%E6%97%B6%E5%BC%82%E5%B8%B8"><span class="nav-number">1.3.41.</span> <span class="nav-text">受检查异常和运行时异常</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#super%E5%87%BA%E7%8E%B0%E5%9C%A8%E7%88%B6%E7%B1%BB%E7%9A%84%E5%AD%90%E7%B1%BB%E4%B8%AD%E3%80%82%E6%9C%89%E4%B8%89%E7%A7%8D%E5%AD%98%E5%9C%A8%E6%96%B9%E5%BC%8F"><span class="nav-number">1.3.42.</span> <span class="nav-text">super出现在父类的子类中。有三种存在方式</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#this-amp-super-%E5%9C%A8%E6%9E%84%E9%80%A0%E6%96%B9%E6%B3%95%E4%B8%AD%E7%9A%84%E5%8C%BA%E5%88%AB"><span class="nav-number">1.3.43.</span> <span class="nav-text">this() &amp; super()在构造方法中的区别</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E4%BF%AE%E9%A5%B0%E7%AC%A6%E4%B8%80%E8%A7%88"><span class="nav-number">1.3.44.</span> <span class="nav-text">修饰符一览</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%9E%84%E9%80%A0%E5%86%85%E9%83%A8%E7%B1%BB%E5%92%8C%E9%9D%99%E6%80%81%E5%86%85%E9%83%A8%E7%B1%BB%E5%AF%B9%E8%B1%A1"><span class="nav-number">1.3.45.</span> <span class="nav-text">构造内部类和静态内部类对象</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%BA%8F%E5%88%97%E5%8C%96"><span class="nav-number">1.3.46.</span> <span class="nav-text">序列化</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F"><span class="nav-number">1.3.47.</span> <span class="nav-text">正则表达式</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java%E7%A7%BB%E4%BD%8D%E8%BF%90%E7%AE%97%E7%AC%A6"><span class="nav-number">1.3.48.</span> <span class="nav-text">Java移位运算符</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%BD%A2%E5%8F%82-amp-%E5%AE%9E%E5%8F%82"><span class="nav-number">1.3.49.</span> <span class="nav-text">形参&amp;实参</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%B1%80%E9%83%A8%E5%8F%98%E9%87%8F%E4%B8%BA%E4%BB%80%E4%B9%88%E8%A6%81%E5%88%9D%E5%A7%8B%E5%8C%96"><span class="nav-number">1.3.50.</span> <span class="nav-text">局部变量为什么要初始化</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java%E8%AF%AD%E8%A8%80%E7%9A%84%E9%B2%81%E6%A3%92%E6%80%A7"><span class="nav-number">1.3.51.</span> <span class="nav-text">Java语言的鲁棒性</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java%E8%AF%AD%E8%A8%80%E7%89%B9%E6%80%A7"><span class="nav-number">1.3.52.</span> <span class="nav-text">Java语言特性</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%8C%85%E8%A3%85%E7%B1%BB%E7%9A%84equals-%E6%96%B9%E6%B3%95%E4%B8%8D%E5%A4%84%E7%90%86%E6%95%B0%E6%8D%AE%E8%BD%AC%E5%9E%8B%EF%BC%8C%E5%BF%85%E9%A1%BB%E7%B1%BB%E5%9E%8B%E5%92%8C%E5%80%BC%E9%83%BD%E4%B8%80%E6%A0%B7%E6%89%8D%E7%9B%B8%E7%AD%89%E3%80%82"><span class="nav-number">1.3.53.</span> <span class="nav-text">包装类的equals()方法不处理数据转型，必须类型和值都一样才相等。</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%AD%90%E7%B1%BB%E5%8F%AF%E4%BB%A5%E7%BB%A7%E6%89%BF%E7%88%B6%E7%B1%BB%E7%9A%84%E9%9D%99%E6%80%81%E6%96%B9%E6%B3%95%EF%BC%81%E4%BD%86%E6%98%AF%E4%B8%8D%E8%83%BD%E8%A6%86%E7%9B%96%E3%80%82%E5%9B%A0%E4%B8%BA%E9%9D%99%E6%80%81%E6%96%B9%E6%B3%95%E6%98%AF%E5%9C%A8%E7%BC%96%E8%AF%91%E6%97%B6%E7%A1%AE%E5%AE%9A%E4%BA%86%EF%BC%8C%E4%B8%8D%E8%83%BD%E5%A4%9A%E6%80%81%EF%BC%8C%E4%B9%9F%E5%B0%B1%E6%98%AF%E4%B8%8D%E8%83%BD%E8%BF%90%E8%A1%8C%E6%97%B6%E7%BB%91%E5%AE%9A%E3%80%82"><span class="nav-number">1.3.54.</span> <span class="nav-text">子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#Java%E8%AF%AD%E6%B3%95%E7%B3%96"><span class="nav-number">1.3.55.</span> <span class="nav-text">Java语法糖</span></a></li></ol></li></ol></li></ol>
    </div>
</div>

            </div>
        
    </div>
</div>


                
            </div>

        </div>

        <div class="page-main-content-bottom">
            
<footer class="footer">
    <div class="info-container">
        <div class="copyright-info info-item">
            &copy;
            
            2024
            
                &nbsp;<i class="fas fa-heart icon-animate"></i>
                &nbsp;<a href="/">Blank</a>
            
        </div>
        
            <script async data-pjax
                    src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>
            <div class="website-count info-item">
                
                
            </div>
        
        <div class="theme-info info-item">
            由 <a target="_blank" href="https://hexo.io">Hexo</a> 驱动&nbsp;|&nbsp;主题&nbsp;<a class="theme-version" target="_blank" href="https://github.com/XPoet/hexo-theme-keep">Keep v3.6.1</a>
        </div>
        
        
            <div class="deploy-info info-item">
                
                    <a target="_blank" rel="nofollow" href="https://gitee.com/lucky0915">
                
                    本站由 <span class="tooltip" data-content="Gitee Pages"><img src="/images/deploy-provider/gitee.png"></span> 提供部署服务
                
                    </a>
                
            </div>
        
    </div>
</footer>

        </div>
    </div>

    
        <div class="post-tools">
            <div class="post-tools-container">
    <ul class="tools-list">
        <!-- TOC aside toggle -->
        
            <li class="tools-item flex-center toggle-show-toc">
                <i class="fas fa-list"></i>
            </li>
        

        <!-- go comment -->
        
    </ul>
</div>

        </div>
    

    <div class="right-bottom-side-tools">
        <div class="side-tools-container">
    <ul class="side-tools-list">
        <li class="tools-item tool-font-adjust-plus flex-center">
            <i class="fas fa-search-plus"></i>
        </li>

        <li class="tools-item tool-font-adjust-minus flex-center">
            <i class="fas fa-search-minus"></i>
        </li>

        <li class="tools-item tool-dark-light-toggle flex-center">
            <i class="fas fa-moon"></i>
        </li>

        <!-- rss -->
        

        

        <li class="tools-item tool-scroll-to-bottom flex-center">
            <i class="fas fa-arrow-down"></i>
        </li>
    </ul>

    <ul class="exposed-tools-list">
        <li class="tools-item tool-toggle-show flex-center">
            <i class="fas fa-cog fa-spin"></i>
        </li>
        
            <li class="tools-item tool-scroll-to-top flex-center">
                <i class="arrow-up fas fa-arrow-up"></i>
                <span class="percent"></span>
            </li>
        
    </ul>
</div>

    </div>

    <div class="zoom-in-image-mask">
    <img class="zoom-in-image">
</div>


    
        <div class="search-pop-overlay">
    <div class="popup search-popup">
        <div class="search-header">
          <span class="search-input-field-pre">
            <i class="fas fa-keyboard"></i>
          </span>
            <div class="search-input-container">
                <input autocomplete="off"
                       autocorrect="off"
                       autocapitalize="off"
                       placeholder="搜索..."
                       spellcheck="false"
                       type="search"
                       class="search-input"
                >
            </div>
            <span class="close-popup-btn">
                <i class="fas fa-times"></i>
            </span>
        </div>
        <div id="search-result">
            <div id="no-result">
                <i class="fas fa-spinner fa-pulse fa-5x fa-fw"></i>
            </div>
        </div>
    </div>
</div>

    

</main>



<script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/utils.js"></script><script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/main.js"></script><script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/header-shrink.js"></script><script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/back2top.js"></script><script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/dark-light-toggle.js"></script>




    <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/local-search.js"></script>



    <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/code-block.js"></script>



    <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/lazyload.js"></script>


<div class="post-scripts pjax">
    
        <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/post-helper.js"></script>
        
            <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/libs/anime.min.js"></script>
        
        
            <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/toc.js"></script>
        
    
</div>


    <script src="//cdn.jsdelivr.net/npm/hexo-theme-keep@3.6.1/source/js/libs/pjax.min.js"></script>
<script>
    window.addEventListener('DOMContentLoaded', () => {
        window.pjax = new Pjax({
            selectors: [
                'head title',
                '.page-container',
                '.pjax'
            ],
            history: true,
            debug: false,
            cacheBust: false,
            timeout: 0,
            analytics: false,
            currentUrlFullReload: false,
            scrollRestoration: false,
            // scrollTo: true,
        });

        document.addEventListener('pjax:send', () => {
            KEEP.utils.pjaxProgressBarStart();
        });

        document.addEventListener('pjax:complete', () => {
            KEEP.utils.pjaxProgressBarEnd();
            window.pjax.executeScripts(document.querySelectorAll('script[data-pjax], .pjax script'));
            KEEP.refresh();
        });
    });
</script>



</body>
</html>
